<FrameworkSwitchCourse {fw} />

# အားလုံးကို ပေါင်းစပ်ခြင်း[[putting-it-all-together]]

<CourseFloatingBanner chapter={2}
  classNames="absolute z-10 right-0 top-0"
  notebooks={[
    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/en/chapter2/section6_pt.ipynb"},
    {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter2/section6_pt.ipynb"},
]} />

နောက်ဆုံးအပိုင်းအချို့မှာတော့ ကျွန်တော်တို့ အလုပ်အများစုကို ကိုယ်တိုင်လုပ်ဆောင်ဖို့ အစွမ်းကုန် ကြိုးစားခဲ့ပါတယ်။ tokenizers တွေ ဘယ်လိုအလုပ်လုပ်တယ်ဆိုတာကို လေ့လာခဲ့ပြီး tokenization, input IDs အဖြစ် ပြောင်းလဲခြင်း၊ padding, truncation, နဲ့ attention masks တွေအကြောင်းကို လေ့လာခဲ့ပါတယ်။

သို့သော်လည်း၊ အပိုင်း ၂ မှာ ကျွန်တော်တို့ တွေ့ခဲ့ရသလိုပဲ၊ 🤗 Transformers API က ဒါတွေအားလုံးကို ကျွန်တော်တို့အတွက် အဆင့်မြင့် function တစ်ခုနဲ့ ကိုင်တွယ်ပေးနိုင်ပြီး၊ အဲဒါကို ဒီနေရာမှာ ကျွန်တော်တို့ နက်ရှိုင်းစွာ လေ့လာပါမယ်။ သင်ရဲ့ `tokenizer` ကို စာကြောင်းပေါ်မှာ တိုက်ရိုက် ခေါ်ဆိုတဲ့အခါ၊ သင်ရဲ့ model ကို ဖြတ်သန်းဖို့ အဆင်သင့်ဖြစ်နေတဲ့ inputs တွေကို ပြန်ရပါလိမ့်မယ်။

```py
from transformers import AutoTokenizer

checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)

sequence = "I've been waiting for a HuggingFace course my whole life."

model_inputs = tokenizer(sequence)
```

ဒီနေရာမှာ `model_inputs` variable မှာ model တစ်ခု ကောင်းကောင်း အလုပ်လုပ်နိုင်ဖို့ လိုအပ်တဲ့ အရာအားလုံး ပါဝင်ပါတယ်။ DistilBERT အတွက်ဆိုရင်၊ အဲဒါက input IDs တွေအပြင် attention mask ပါ ပါဝင်ပါတယ်။ အပို inputs တွေကို လက်ခံတဲ့ တခြား model တွေအတွက်လည်း `tokenizer` object က အဲဒါတွေကို output အဖြစ် ထုတ်ပေးပါလိမ့်မယ်။

အောက်ပါ ဥပမာအချို့မှာ ကျွန်တော်တို့ မြင်ရမယ့်အတိုင်း၊ ဒီ method က အလွန်အစွမ်းထက်ပါတယ်။ ပထမဆုံးအနေနဲ့၊ ဒါက single sequence တစ်ခုကို tokenize လုပ်ဆောင်နိုင်ပါတယ်။

```py
sequence = "I've been waiting for a HuggingFace course my whole life."

model_inputs = tokenizer(sequence)
```

ဒါက API မှာ ဘာမှမပြောင်းလဲဘဲ sequence များစွာကို တစ်ပြိုင်နက်တည်း ကိုင်တွယ်နိုင်ပါတယ်။

```py
sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"]

model_inputs = tokenizer(sequences)
```

ဒါက ရည်ရွယ်ချက်အမျိုးမျိုးအရ pad လုပ်နိုင်ပါတယ်။

```py
# Sequences တွေကို အရှည်ဆုံး sequence length အထိ pad လုပ်ပါလိမ့်မယ်။
model_inputs = tokenizer(sequences, padding="longest")

# Sequences တွေကို model ရဲ့ max length (BERT ဒါမှမဟုတ် DistilBERT အတွက် 512) အထိ pad လုပ်ပါလိမ့်မယ်။
model_inputs = tokenizer(sequences, padding="max_length")

# Sequences တွေကို သတ်မှတ်ထားတဲ့ max length အထိ pad လုပ်ပါလိမ့်မယ်။
model_inputs = tokenizer(sequences, padding="max_length", max_length=8)
```

ဒါက sequences တွေကို truncate လည်း လုပ်နိုင်ပါတယ်။

```py
sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"]

# Model ရဲ့ max length (BERT ဒါမှမဟုတ် DistilBERT အတွက် 512) ထက် ပိုရှည်တဲ့ sequences တွေကို truncate လုပ်ပါလိမ့်မယ်။
model_inputs = tokenizer(sequences, truncation=True)

# သတ်မှတ်ထားတဲ့ max length ထက် ပိုရှည်တဲ့ sequences တွေကို truncate လုပ်ပါလိမ့်မယ်။
model_inputs = tokenizer(sequences, max_length=8, truncation=True)
```

`tokenizer` object က သီးခြား framework tensors တွေအဖြစ် ပြောင်းလဲခြင်းကို ကိုင်တွယ်နိုင်ပါတယ်။ ၎င်းတို့ကို model ကို တိုက်ရိုက် ပို့နိုင်ပါတယ်။ ဥပမာအားဖြင့်၊ အောက်ပါ code sample မှာ ကျွန်တော်တို့က tokenizer ကို မတူညီတဲ့ frameworks တွေကနေ tensors တွေကို ပြန်ပေးဖို့ တောင်းဆိုနေတာပါ။ `"pt"` က PyTorch tensors တွေကို ပြန်ပေးပြီး `"np"` က NumPy arrays တွေကို ပြန်ပေးပါတယ်။

```py
sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"]

# PyTorch tensors များကို ပြန်ပေးသည်။
model_inputs = tokenizer(sequences, padding=True, return_tensors="pt")

# NumPy arrays များကို ပြန်ပေးသည်။
model_inputs = tokenizer(sequences, padding=True, return_tensors="np")
```

## Special Tokens များ[[special-tokens]]

tokenizer က ပြန်ပေးတဲ့ input IDs တွေကို ကြည့်လိုက်ရင်၊ အစောပိုင်းက ကျွန်တော်တို့ ရရှိခဲ့တာတွေနဲ့ အနည်းငယ် ကွဲပြားနေတာကို တွေ့ရပါလိမ့်မယ်။

```py
sequence = "I've been waiting for a HuggingFace course my whole life."

model_inputs = tokenizer(sequence)
print(model_inputs["input_ids"])

tokens = tokenizer.tokenize(sequence)
ids = tokenizer.convert_tokens_to_ids(tokens)
print(ids)
```

```python out
[101, 1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012, 102]
[1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012]
```

token ID တစ်ခုကို အစမှာ ထည့်သွင်းထားပြီး၊ တစ်ခုကို အဆုံးမှာ ထည့်သွင်းထားပါတယ်။ ဒါက ဘာအကြောင်းလဲဆိုတာ သိဖို့ အထက်ပါ IDs sequence နှစ်ခုကို decode လုပ်ကြည့်ရအောင်။

```py
print(tokenizer.decode(model_inputs["input_ids"]))
print(tokenizer.decode(ids))
```

```python out
"[CLS] i've been waiting for a huggingface course my whole life. [SEP]"
"i've been waiting for a huggingface course my whole life."
```

tokenizer က အစမှာ `[CLS]` ဆိုတဲ့ special word ကို ထည့်ထားပြီး၊ အဆုံးမှာ `[SEP]` ဆိုတဲ့ special word ကို ထည့်ထားပါတယ်။ ဒါက model ကို အဲဒီ tokens တွေနဲ့ pretrained လုပ်ထားတာကြောင့် ဖြစ်ပြီး၊ inference အတွက် တူညီတဲ့ ရလဒ်တွေ ရရှိဖို့အတွက် ကျွန်တော်တို့လည်း ဒါတွေကို ထည့်ဖို့ လိုအပ်ပါတယ်။ တချို့ model တွေက special words တွေ မထည့်တာ ဒါမှမဟုတ် မတူညီတဲ့ special words တွေ ထည့်တာမျိုး ရှိနိုင်ပါတယ်။ model တွေက special words တွေကို အစမှာပဲ ဒါမှမဟုတ် အဆုံးမှာပဲ ထည့်တာမျိုးလည်း ရှိနိုင်ပါတယ်။ ဘယ်လိုပဲဖြစ်ဖြစ်၊ tokenizer က ဘယ် special tokens တွေ လိုအပ်တယ်ဆိုတာ သိပြီး သင့်အတွက် ဒါတွေကို ကိုင်တွယ်ပေးပါလိမ့်မယ်။

## အနှစ်ချုပ်: Tokenizer မှ Model ဆီသို့[[wrapping-up-from-tokenizer-to-model]]

`tokenizer` object က text တွေပေါ်မှာ အသုံးပြုတဲ့အခါ တစ်ဦးချင်းစီ အဆင့်တွေကို အားလုံး မြင်ပြီးသွားပြီဆိုတော့၊ ဒါက sequences များစွာကို (padding!)၊ အလွန်ရှည်လျားတဲ့ sequences တွေကို (truncation!) နဲ့ မတူညီတဲ့ tensors အမျိုးအစားများစွာကို သူ့ရဲ့ အဓိက API နဲ့ ဘယ်လိုကိုင်တွယ်လဲဆိုတာကို နောက်ဆုံးတစ်ကြိမ် ကြည့်ရအောင်။

```py
import torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification

checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"]

tokens = tokenizer(sequences, padding=True, truncation=True, return_tensors="pt")
output = model(**tokens)
```

## ဝေါဟာရ ရှင်းလင်းချက် (Glossary)

*   **Tokenizer**: စာသား (သို့မဟုတ် အခြားဒေတာ) ကို AI မော်ဒယ်များ စီမံဆောင်ရွက်နိုင်ရန် tokens တွေအဖြစ် ပိုင်းခြားပေးသည့် ကိရိယာ သို့မဟုတ် လုပ်ငန်းစဉ်။
*   **Tokenization**: စာသားကို tokens များအဖြစ် ပိုင်းခြားသော လုပ်ငန်းစဉ်။
*   **Input IDs**: Tokenizer မှ ထုတ်ပေးသော tokens တစ်ခုစီ၏ ထူးခြားသော ဂဏန်းဆိုင်ရာ ID များ။
*   **Padding**: မတူညီသော အရှည်ရှိသည့် input sequence များကို အရှည်တူညီအောင် သတ်မှတ်ထားသော တန်ဖိုးများဖြင့် ဖြည့်စွက်ခြင်း။
*   **Truncation**: အရှည်ကန့်သတ်ချက်ထက် ပိုနေသော input sequence များကို ဖြတ်တောက်ခြင်း။
*   **Attention Mask**: မော်ဒယ်ကို အာရုံစိုက်သင့်သည့် tokens များနှင့် လျစ်လျူရှုသင့်သည့် (padding) tokens များကို ခွဲခြားပေးသည့် binary mask။
*   **🤗 Transformers API**: Hugging Face Transformers library ကို အသုံးပြုရန်အတွက် ပရိုဂရမ်မာများက ခေါ်ဆိုနိုင်သော လုပ်ဆောင်ချက်များ၊ class များ နှင့် methods များ။
*   **`AutoTokenizer` Class**: Hugging Face Transformers library မှာ ပါဝင်တဲ့ class တစ်ခုဖြစ်ပြီး မော်ဒယ်အမည်ကို အသုံးပြုပြီး သက်ဆိုင်ရာ tokenizer ကို အလိုအလျောက် load လုပ်ပေးသည်။
*   **`from_pretrained()` Method**: Pre-trained model သို့မဟုတ် tokenizer ကို load လုပ်ရန် အသုံးပြုသော method။
*   **`distilbert-base-uncased-finetuned-sst-2-english`**: `sentiment-analysis` pipeline ၏ default checkpoint အဖြစ် အသုံးပြုသော DistilBERT မော်ဒယ်၏ အမည်။ `base` သည် မော်ဒယ်၏ အရွယ်အစားကို ဖော်ပြပြီး `uncased` သည် စာလုံးအကြီးအသေး ခွဲခြားခြင်းမရှိဘဲ လေ့ကျင့်ထားကြောင်း ဖော်ပြသည်။ `finetuned-sst-2-english` က SST-2 dataset တွင် English ဘာသာစကားအတွက် fine-tune လုပ်ထားသည်ကို ဆိုလိုသည်။
*   **`model_inputs` Variable**: tokenizer ကနေ ထွက်လာတဲ့ model ရဲ့ inputs တွေအားလုံးကို သိမ်းဆည်းထားတဲ့ variable။
*   **PyTorch Tensors**: PyTorch deep learning framework မှာ ဒေတာတွေကို ကိုယ်စားပြုသော multi-dimensional array များ။
*   **NumPy Arrays**: Python တွင် ဂဏန်းတွက်ချက်မှုများအတွက် အသုံးပြုသော multi-dimensional array များအတွက် library။
*   **`padding="longest"`**: Batch အတွင်းရှိ အရှည်ဆုံး sequence အထိ pad လုပ်ခြင်း။
*   **`padding="max_length"`**: Model ၏ အများဆုံး length အထိ pad လုပ်ခြင်း။
*   **`max_length`**: Padding သို့မဟုတ် truncation အတွက် သတ်မှတ်ထားသော အရှည် ကန့်သတ်ချက်။
*   **`truncation=True`**: Sequences များကို သတ်မှတ်ထားသော length အထိ ဖြတ်တောက်ခြင်း။
*   **`return_tensors="pt"`**: PyTorch tensors များကို ပြန်ပေးရန် tokenizer ကို ညွှန်ကြားခြင်း။
*   **`return_tensors="np"`**: NumPy arrays များကို ပြန်ပေးရန် tokenizer ကို ညွှန်ကြားခြင်း။
*   **Special Tokens**: Transformer model များက စာကြောင်းနယ်နိမိတ်များ သို့မဟုတ် အခြားအချက်အလက်များကို ကိုယ်စားပြုရန် အသုံးပြုသော အထူး tokens များ (ဥပမာ - `[CLS]`, `[SEP]`, `[PAD]`)။
*   **`[CLS]`**: BERT မော်ဒယ်တွင် classification task အတွက် အသုံးပြုသော special token (စာကြောင်း၏ အစတွင် ပေါ်လာသည်)။
*   **`[SEP]`**: BERT မော်ဒယ်တွင် စာကြောင်းများကြား ပိုင်းခြားရန် အသုံးပြုသော special token။
*   **`tokenizer.decode()` Method**: Token IDs များကို မူရင်းစာသားသို့ ပြန်ပြောင်းလဲပေးသော method။
*   **Inference**: လေ့ကျင့်ပြီးသား Artificial Intelligence (AI) မော်ဒယ်တစ်ခုကို အသုံးပြုပြီး input data ကနေ ခန့်မှန်းချက်တွေ ဒါမှမဟုတ် output တွေကို ထုတ်လုပ်တဲ့ လုပ်ငန်းစဉ်။
*   **`AutoModelForSequenceClassification` Class**: Hugging Face Transformers library မှာ ပါဝင်တဲ့ class တစ်ခုဖြစ်ပြီး sequence classification အတွက် pre-trained model ကို အလိုအလျောက် load လုပ်ပေးသည်။
*   **`model(**tokens)`**: tokenizer ကနေ ထုတ်ပေးတဲ့ dictionary ကို model ရဲ့ input အဖြစ် ထည့်သွင်းပေးခြင်း။